<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Cactus, tests unitaires sur des Servlet</title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
        <keywords>Cactus, Java, Tomcat</keywords>
        <author>Terry PRUDENT</author>
        <keywords />
    </head>
    <body>
        <div class="chapter">
            <h2>1. Introduction</h2>
            <p>
                Durant la réalisation d’un projet figure de nombreuses étapes essentielles parmi lesquelles on retrouve immanquablement une ou plusieurs phases de test. Cependant, certains problèmes peuvent se poser lorsqu’il s’agit de composant du J2EE.
                <br />
                En effet, le J2EE est un environnement complexe. Il comprend des composants qui ne s’exécutent que dans en environnement particulier tel que les EJB ou les Servlets. Ainsi cet environnement spécial se comporte en container et gère de nombreux services relatifs au composant qui s’y exécute. Dans un tel contexte, il peut être long de mettre en place un test pour l’application.
				Une solution possible serait de réaliser le test à l’intérieur d’un conteneur J2EE, dans ce cas, il serait nécessaire d’avoir une interface permettant d’appeler le composant coté serveur directement. C’est en partie le travail que réalise Cactus en mettant a votre disposition des outils pour réaliser des tests de composants coté serveur.
            </p>
        </div>
        <div class="chapter">
            <h2>2.Présentation</h2>
            <div class="subChapter">
                <h3>2.1.Projet Cactus</h3>
                <p>Le projet Cactus est né de l’envie de fournir aux développeurs des outils simples et fiables de test. De cette idée est né un framework de test dont le but est de couvrir l’ensemble des models de composants du J2EE et peut être éventuellement d’autre type de composants.
					Le framework Cactus permet de faciliter les tests de portions de codes java s’exécutant via un serveur tel que les Servlets ou encore, les Enterprise Java Beans (EJB), permettant ainsi de réduire les coûts et le temps nécessaire à la réalisation de ces tests. Pour cela, Catcus utilise JUnit, un framework de test célèbre chez les programmeurs adeptes d’Extreme Programming, et dont il hérite.
					Afin de réaliser ces tests, Cactus implémente une stratégie basée sur des conteneurs, ce qui signifie que les tests sont réalisés à l’intérieur de conteneurs.</p>
            </div>
            <div class="subChapter">
                <h3>2.2.Eco system Cactus</h3>
                <p>
                    L’éco system Cactus se compose de plusieurs éléments fournit dans la distribution Cactus, qui permettront de mettre en place et fourniront des exemples clairs pour utiliser le framework Cactus :
                    <br />
                    * Le framework Cactus, bien évidement, qui fournit l’ensemble des API permettant de réaliser des tests Cactus.
                    <br />
                    * Les modules d’intégrations Cactus, qui sont des modules permettant d’utiliser le framework Cactus de façon simple suivant l’environnement de développement.
                    <br />
                    * Les « Cactus Samples », qui sont des exemples, de simples projets qui montrent comment écrire un test Cactus, ou comment utiliser certains des modules d’intégration.
                </p>
            </div>
        </div>
        <div class="chapter">
            <h2>3.« Installation » de Cactus</h2>
            <div class="subChapter">
                <h3>3.1.Avant propos</h3>
                <p>Dans la mesure ou Cactus est avant tout un framework, il n’existe pas réellement de façon « d’installer » Cactus, mais plutôt différentes façons de l’intégrer à votre environnement de développement. Il existe, pour ce faire, différents modules d’intégration dépendant de votre environnement. Dans la suite de cet article, nous prendrons comme exemple l’implémentation de Cactus dans un environnement Tomcat.</p>
            </div>
            <div class="subChapter">
                <h3>3.2.Pré requis</h3>
                <p>
                    Afin d’exécuter un test Cactus dans votre environnement il sera nécessaire d’avoir les éléments suivant installer sur votre machine :
                    <br />
                    * La Java Virtual Machine (JVM), la version 1.2 ou supérieur doit être présente pour pouvoir effectuer un test via le framework Cactus. C’est aussi un pré-requis pour pouvoir utiliser les servlets.
                    <br />
                    * Un moteur de Servlet J2EE, afin de pouvoir lancer des Test Cactus sur votre PC, la version Servlet 2.x / J2EE 1.x doit être présente sur la machine.
                </p>
            </div>
            <div class="subChapter">
                <h3>3.3.Fichiers composants Cactus</h3>
                <p>
                    Cactus se compose d’un ensemble de fichier JAR essentiels pour la réalisation de tests reposants sur le framework de test Cactus :
                    <br />
                    * cactus.jar : il s’agit ici du JAR principal qui contient l’ensemble des classes du framework.
                    <br />
                    * httpclient.jar : ce Jar est important car Cactus repose essentiellement sur le framework Jakarta Commons HttpClient pour la gestion des Cookies.
                    <br />
                    * commons-logging.jar :
                    <br />
                    * junit.jar : comme nous avons pu le voir, Cactus utilise JUnit, c’est pourquoi ce fichier JAR est requis pour pouvoir utiliser les classes de Cactus.
                    <br />
                    * aspectjrt.jar : Cactus utilise AspectJ pour la réalisation de certaines tâches, ce fichier JAR est donc tout autant nécessaire que les précédents.
                </p>
                <p>
                    Ces fichiers représentent le minimum nécessaire à mettre en place pour pouvoir réaliser, il existe cependant d’autres fichiers JAR ayants des rôle plus précis :
                    <br />
                    * cactus-ant.jar : permet de faciliter l’intégration du framework via des tâches Ant contenues dans le JAR.
                    <br />
                    * servletapi.jar : ce fichier JAR est requis pour réaliser des projets basés sur les servlets.
                    <br />
                    * httpunit.jar
                    <br />
                    * nekohtml.jar : ce fichier JAR est requis pour réaliser des projets utilisant httpUnit.
                </p>
            </div>
            <div class="subChapter">
                <h3>3.4.Mise en place du framework avec Tomcat</h3>
                <p>Il existe plusieurs méthodes, la plupart du temps assez simples, pour intégrer le framework Cactus à votre environnement de travail, chacune de ces méthodes dépendant justement de cet environnement. Dans les lignes qui vont suivre, je présenterai la méthode d’intégration relative à Tomcat, vous pouvez cependant retrouver l’ensemble des différents modules d’intégration sur cette page.</p>
                <h4>3.4.1.Tomcat et les fichiers de Cactus</h4>
                <p>En premier lieu, il vous faut vous assurer de posséder une version de Tomcat supérieure ou égale à la 4.0. Vous trouverez dans le répertoire d’installation de Tomcat un répertoire ‘/common’ qui contient lui-même un répertoire ‘/lib’. C’est dans ce répertoire que vous devrez copier les différents fichiers JAR qui composent Cactus.
					Comme nous l’avons vu précédemment, il est nécessaire de posséder au moins les fichiers Cactus.jar, httpclient.jar, commons-logging.jar, junit.jar et aspectjr.jar pour pouvoir exécuter un test via le framework Cactus, ces fichiers devront donc être tous placés dans le répertoire ‘/common/lib’ du répertoire d’installation de Tomcat.</p>
                <h4>3.4.2.Modification du fichier web.xml de Tomcat</h4>
                <p>
                    Il vous faut maintenant éditer le fichier web.xml situé dans le répertoire ‘/conf’ lui-même situé dans le répertoire d’installation de Tomcat. Vous devrez ajouter les lignes suivantes au début du fichier, après l’élément ‘
                    <webapp>’ , cette opération doit être réalisée prudemment, il est d’ailleurs conseillé de faire une sauvegarde de l’ancien fichier web.xml au cas où une erreur surviendrait après modification :</webapp>
                </p>
                <textarea name="code" class="xml">
                    <servlet>
                        <servlet-name>ServletRedirector</servlet-name>
                        <servlet-class>org.apache.cactus.server.ServletTestRedirector</servlet-class>
                        <init-param>
                            <param-name>param1</param-name>
                            <param-value>value1 used for testing</param-value>
                        </init-param>
                    </servlet>
                    <servlet>
                        <servlet-name>ServletTestRunner</servlet-name>
                        <servlet-class>org.apache.cactus.server.runner.ServletTestRunner</servlet-class>
                    </servlet>
                </textarea>
                <p>
                    Il y a un second élément à rajouter dans ce fichier après la dernière définition ‘
                    <servlet>’, où vous devez rajouter les lignes suivantes :</servlet>
                </p>
                <textarea name="code" class="xml">
                    <servlet-mapping>
                        <servlet-name>ServletRedirector</servlet-name>
                        <url-pattern>/ServletRedirector</url-pattern>
                    </servlet-mapping>
                    <servlet-mapping>
                        <servlet-name>ServletTestRunner</servlet-name>
                        <url-pattern>/ServletTestRunner</url-pattern>
                    </servlet-mapping>
                </textarea>
                <p>Vous pouvez maintenant sauvegardez les modifications réalisées sur votre fichier web.xml, votre environnement est alors prêt pour la réalisation de test utilisant le framework Cactus.</p>
            </div>
        </div>
        <div class="chapter">
            <h2>4.Réaliser un test avec Cactus</h2>
            <div class="subChapter">
                <h3>4.1.Ecriture d’un test pour un Servlet</h3>
                <p>
                    Il existe plusieurs étapes par lesquelles il faut passer pour écrire un test avec Cactus. Dans les lignes qui vont suivre, je présenterai quelques une des méthodes permettant de réaliser un test pour un code utilisant les objets de l’API Servlet. Vous pouvez retrouver l’ensemble de ces étapes ainsi que des informations supplémentaires concernant les méthodes de Cactus à cette
                    <a href="http://jakarta.apache.org/cactus/writing/howto_testcase.html" target="”_blank”">adresse</a>
                    .
                </p>
                <p>
                    - Dans une première étape, il vous faut importer les packages ‘org.apache.cactus’ et ‘junit.framework’ afin de réaliser le test. Le premier package contient bien évidement les classes de Cactus, le second package quand à lui, est nécessaire car Cactus utilise JUnit comme ‘client’ pour appeler les tests de l’application. Vous devriez donc obtenir les lignes suivantes :
                    <textarea name="code" class="java">
                        import org.apache.cactus.*;
                        <br />
                        import junit.framework.*;
                    </textarea>
                </p>
                <p>- Dans une seconde étape, il vous faut créer une classe de test qui hérite d’une des classes de test de Cactus. Il existe plusieurs classes de test dont l’utilisation dépend de l’objet que vous souhaitez tester.</p>
                <p>Pour tester un code utilisant des objets de l’API Servlet tels que HttpServletRequest, HttpServletResponse, ServletConfig, etc … , il faut créer une classe qui hérite de la classe ServletTestCase.</p>
                <textarea name="code" class="java">public class MyTestServlet extends ServletTestCase
					{
					...
					}</textarea>
                <p>Suivant ce même principe, vous pouvez créer des classes permettant de tester des codes utilisant des objets de l’API JSP, en héritant de la classe JspTestCase, ainsi que ceux utilisant des objets de l’API Filter, en héritant de la classe FilterTestCase. Vous avez aussi la possibilité de réutiliser une classe héritant de TestCase de l’API JUnit, pour cela il faut utiliser la classe ServletTestSuite.</p>
                <p>
                    - Dans une dernière étape, il vous faut utiliser la méthode testXXX() de votre classe de test, méthode similaire à la méthode de Junit portant le même nom, mais qui a pour particularité de s’exécuter à l’intérieur d’un conteneur. Dans cette classe, vous allez réaliser les opérations suivantes :
                    <br />
                    * Instancier la classe que vous souhaitez tester.
                    <br />
                    * Mettre en place les différents objets coté serveur (Comme ajouter une variable dans la session http).
                    <br />
                    * Appeler la méthode à tester.
                    <br />
                    * Effectuer les assertions standard de JUnit via les méthodes assert(…), assertEqual(…), fail(…), afin de vérifier la réussite du test.
                </p>
                <p>Il existe aussi d’autres méthodes optionnelles que vous pouvez choisir ou non d’utiliser. Ainsi, la méthode beginXXX(…) vous permettra d’initialiser les paramètres http, ces paramètres pourront ensuite être récupérer dans votre méthode testXXX(…) . De même, la méthode endXXX(…) permettra de récupérer une valeur d’un paramètre http renvoyé par le test tel qu’un cookie ou une réponse http.</p>
            </div>
            <div class="subChapter">
                <h3>4.2.Exemple</h3>
                Voici un exemple de test via Cactus que l’on peut trouver sur le site du projet Jakarta :
                <br />
                La classe a tester :
                <textarea name="code" class="java">import javax.servlet.http.HttpServlet;
					import javax.servlet.http.HttpServletRequest;
					public class SampleServlet extends HttpServlet
					{
					public void saveToSession(HttpServletRequest request)
					{
					String testparam = request.getParameter("testparam");
					request.getSession().setAttribute("testAttribute", testparam);
					}
					}</textarea>
                <p>La classe de test :</p>
                <textarea name="code" class="java">public class TestSampleServlet extends ServletTestCase
					{
					public TestSampleServlet(String theName)
					{
					super(theName);
					}
					public static Test suite()
					{
					return new TestSuite(TestSampleServlet.class);
					}
					public void beginSaveToSessionOK(WebRequest webRequest)
					{
					webRequest.addParameter("testparam", "it works!");
					}
					public void testSaveToSessionOK()
					{
					SampleServlet servlet = new SampleServlet();
					servlet.saveToSession(request);
					assertEquals("it works!", session.getAttribute("testAttribute"));
					}
					}</textarea>
            </div>
            <div class="subChapter">
                <h3>4.3.Lancer le test</h3>
                <p>
                    Afin de pouvoir exécuter le test préalablement écrit, il vous faut le déployer sur le serveur, de la même façon que pour une application c'est-à-dire, en créant la hiérarchie de dossiers de votre application et en mettant les fichier .class de votre classe de test, ainsi que ceux de votre application à tester dans le répertoire ‘WEB-INF/classes’. Une fois cette opération réalisée, vous pourrez accéder au test de votre application en ouvrant une fenêtre de votre navigateur internet et en entrant cette
                    <a href="http://localhost:8080/dossier_mon_application/ServletTestRunner?suite=class_de_test" target="”_blank”">adresse</a>
                    .
					Les résultats du test vous seront affichés sous la forme d’un fichier XML dont la forme devrait être la suivante :
                </p>
                <textarea name="code" class="xml">
                    &lt;?xml version=”1.0” encoding=”UTF-8” ?&gt;
                    <testsuites>
                        <testsuite name="”class_de_test”" tests="”1”" failures="”0”" errors="”0”" time="”0.27”">
                            <testcase name="”methode_a_tester”" time="”0.2”" />
                        </testsuite>
                    </testsuites>
                </textarea>
                <p>
                    Un autre affichage présentant les informations du test à l’intérieur de tableaux de données, existe. Pour obtenir cet affichage, il vous faudra télécharger la feuille de style XSLT et placer cette feuille de style dans le répertoire de votre application. Il vous faudra ensuite réaliser votre test en utilisant cette
                    <a href="http://localhost:8080/dossier_mon_application/ServletTestRunner?suite=class_de_test&amp;xls=cactus-report.xsl" target="”_blank”">adresse</a>
                    .
                </p>
            </div>
        </div>
        <div class="chapter">
            <h2>5.Conclusion</h2>
            <p>Cet article vous a donc présenté le framework Cactus, framework dont la particularité est de vous proposer des outils afin de tester des composants côté serveur à l’intérieur de conteneur. Comme l’explique l’équipe de développement du projet Cactus, il se développe de plus en plus de composants et les conteneurs proposent de plus en plus de services relatifs à ces composants, il est donc important que se développent de tels projets afin de faciliter les tests de ces composants et permettre aux développeurs de se concentrer d’avantage sur le développement de l’application en leur assurant le bon fonctionnement de leur application une fois déployée.</p>
        </div>
        <div class="chapter">
            <h2>6.Sources d’informations</h2>
            <p>
                L’essentiel des informations présentées ici a été collecté sur le site du projet Jakarta que vous pouvez visiter à cette
                <a href="http://jakarta.apache.org/cactus/" target="”_blank”">adresse</a>
                .
            </p>
        </div>
    </body>
</html>

